home *** CD-ROM | disk | FTP | other *** search
/ IRIS Performer 2.2 Friends Demo / SGI IRIS Performer 2.2 Friends Demo.iso / friends / openworlds / tix / ResizeH.tcl < prev    next >
Text File  |  1997-11-22  |  13KB  |  478 lines
  1. # tixResizeHandle --
  2. #
  3. #    A general purpose "resizing handle" widget. You can use it to
  4. #    resize pictures, widgets, etc. When using it to resize a widget,
  5. #    you can use the "attachwidget" command to attach it to a
  6. #    widget and it will handle all the events for you.
  7. #
  8. #
  9.  
  10. tixWidgetClass tixResizeHandle {
  11.     -classname TixResizeHandle
  12.     -superclass tixVResize
  13.  
  14.     -method {
  15.     attachwidget detachwidget hide show
  16.     }
  17.     -flag {
  18.     -command -cursorfg -cursorbg -handlesize -hintcolor -hintwidth -x -y
  19.     }
  20.     -configspec {
  21.     {-command command Command {}}
  22.     {-cursorfg cursorFg CursorColor white}
  23.     {-cursorbg cursorBg CursorColor red}
  24.     {-handlesize handleSize HandleSize 6}
  25.     {-hintcolor hintColor HintColor red}
  26.     {-hintwidth hintWidth HintWidth 1}
  27.     {-x x X 0}
  28.     {-y y Y 0}
  29.     }
  30. }
  31.  
  32. proc tixResizeHandle::InitWidgetRec {w} {
  33.     upvar #0 $w data
  34.  
  35.     tixChainMethod $w InitWidgetRec
  36.  
  37.     set data(shown)  0
  38.     set data(widget) {}
  39. }
  40.  
  41. proc tixResizeHandle::ConstructWidget {w} {
  42.     upvar #0 $w data
  43.  
  44.     tixChainMethod $w ConstructWidget
  45.  
  46.     # Create the hints
  47.     #
  48.     set data(w_ht) $w:tix_priv_ht
  49.     set data(w_hb) $w:tix_priv_hb
  50.     set data(w_hl) $w:tix_priv_hl
  51.     set data(w_hr) $w:tix_priv_hr
  52.  
  53.     frame $data(w_ht) -height $data(-hintwidth) -bg $data(-background)
  54.     frame $data(w_hb) -height $data(-hintwidth) -bg $data(-background)
  55.     frame $data(w_hl) -width  $data(-hintwidth) -bg $data(-background)
  56.     frame $data(w_hr) -width  $data(-hintwidth) -bg $data(-background)
  57.  
  58.     # Create the corner resize handles
  59.     #
  60.     set data(w_r00) $w
  61.  
  62.     $data(rootCmd) config\
  63.     -cursor "top_left_corner $data(-cursorbg) $data(-cursorfg)"
  64.  
  65.     set data(w_r01) $w:tix_priv_01
  66.     set data(w_r10) $w:tix_priv_10
  67.     set data(w_r11) $w:tix_priv_11
  68.  
  69.     frame $data(w_r01) -relief $data(-relief) -bd $data(-borderwidth) \
  70.     -cursor "bottom_left_corner $data(-cursorbg) $data(-cursorfg)"\
  71.     -bg $data(-background)
  72.     frame $data(w_r10) -relief $data(-relief) -bd $data(-borderwidth) \
  73.     -cursor "top_right_corner $data(-cursorbg) $data(-cursorfg)"\
  74.     -bg $data(-background)
  75.     frame $data(w_r11) -relief $data(-relief) -bd $data(-borderwidth) \
  76.     -cursor "bottom_right_corner $data(-cursorbg) $data(-cursorfg)"\
  77.     -bg $data(-background)
  78.  
  79.     # Create the border resize handles
  80.     #
  81.     set data(w_bt)  $w:tix_priv_bt
  82.     set data(w_bb)  $w:tix_priv_bb
  83.     set data(w_bl)  $w:tix_priv_bl
  84.     set data(w_br)  $w:tix_priv_br
  85.  
  86.     frame $data(w_bt) -relief $data(-relief) -bd $data(-borderwidth) \
  87.     -cursor "top_side $data(-cursorbg) $data(-cursorfg)"\
  88.     -bg $data(-background)
  89.     frame $data(w_bb) -relief $data(-relief) -bd $data(-borderwidth) \
  90.     -cursor "bottom_side $data(-cursorbg) $data(-cursorfg)"\
  91.     -bg $data(-background)
  92.     frame $data(w_bl) -relief $data(-relief) -bd $data(-borderwidth) \
  93.     -cursor "left_side $data(-cursorbg) $data(-cursorfg)"\
  94.     -bg $data(-background)
  95.     frame $data(w_br) -relief $data(-relief) -bd $data(-borderwidth) \
  96.     -cursor "right_side $data(-cursorbg) $data(-cursorfg)"\
  97.     -bg $data(-background)
  98. }
  99.  
  100. proc tixResizeHandle::SetBindings {w} {
  101.     upvar #0 $w data
  102.  
  103.     tixChainMethod $w SetBindings
  104.  
  105.     bind $data(w_r00)   <1> \
  106.     "tixResizeHandle::dragstart $w $data(w_r00)   1 %X %Y  {1  1 -1 -1}"
  107.     bind $data(w_r01)   <1> \
  108.     "tixResizeHandle::dragstart $w $data(w_r01)   1 %X %Y  {1  0 -1  1}"
  109.     bind $data(w_r10)   <1> \
  110.     "tixResizeHandle::dragstart $w $data(w_r10)   1 %X %Y  {0  1  1 -1}"
  111.     bind $data(w_r11)   <1> \
  112.     "tixResizeHandle::dragstart $w $data(w_r11)   1 %X %Y  {0  0  1  1}"
  113.     bind $data(w_bt)    <1> \
  114.     "tixResizeHandle::dragstart $w $data(w_bt)    1 %X %Y  {0  1  0 -1}"
  115.     bind $data(w_bb)    <1> \
  116.     "tixResizeHandle::dragstart $w $data(w_bb)    1 %X %Y  {0  0  0  1}"
  117.     bind $data(w_bl)    <1> \
  118.     "tixResizeHandle::dragstart $w $data(w_bl)    1 %X %Y  {1  0 -1  0}"
  119.     bind $data(w_br)    <1> \
  120.     "tixResizeHandle::dragstart $w $data(w_br)    1 %X %Y  {0  0  1  0}"
  121.  
  122.     foreach win [list \
  123.          $data(w_r00)\
  124.          $data(w_r01)\
  125.          $data(w_r10)\
  126.          $data(w_r11)\
  127.          $data(w_bt)\
  128.          $data(w_bb)\
  129.          $data(w_bl)\
  130.          $data(w_br)\
  131.          ] {
  132.     bind $win <B1-Motion>       "tixVResize::drag    $w %X %Y"
  133.     bind $win <ButtonRelease-1> "tixVResize::dragend $w $win 0 %X %Y"
  134.     bind $win <Any-Escape>      "tixVResize::dragend $w $win 1  0  0"
  135.     }
  136. }
  137.  
  138. #----------------------------------------------------------------------
  139. #         Config Methods
  140. #----------------------------------------------------------------------
  141. proc tixResizeHandle::config-width {w value} {
  142.     tixWidgetDoWhenIdle tixResizeHandle::ComposeWindow $w
  143. }
  144.  
  145. proc tixResizeHandle::config-height {w value} {
  146.     tixWidgetDoWhenIdle tixResizeHandle::ComposeWindow $w
  147. }
  148.  
  149. proc tixResizeHandle::config-x {w value} {
  150.     tixWidgetDoWhenIdle tixResizeHandle::ComposeWindow $w
  151. }
  152.  
  153. proc tixResizeHandle::config-y {w value} {
  154.     tixWidgetDoWhenIdle tixResizeHandle::ComposeWindow $w
  155. }
  156.  
  157.  
  158. #----------------------------------------------------------------------
  159. #         Public Methods
  160. #----------------------------------------------------------------------
  161. proc tixResizeHandle::dragstart {w win depress rootx rooty mrect} {
  162.     upvar #0 $w data
  163.  
  164.     set wx $data(-x)
  165.     set wy $data(-y)
  166.     set ww $data(-width)
  167.     set wh $data(-height)
  168.  
  169.     tixVResize::dragstart $w $win $depress $rootx $rooty \
  170.     [list $wx $wy $ww $wh] $mrect
  171. }
  172.  
  173. proc tixDeleteBindTag {w args} {
  174.     set tags [bindtags $w]
  175.     set newtags {}
  176.  
  177.     foreach tag $tags {
  178.     if {[lsearch $args $tag] == -1} {
  179.         lappend newtags $tag
  180.     }
  181.     }
  182.     bindtags $w $newtags
  183. }
  184.  
  185. proc tixAddBindTag {w args} {
  186.     bindtags $w [concat [bindtags $w] $args]
  187. }
  188.  
  189. proc tixResizeHandle::attachwidget {w widget args} {
  190.     upvar #0 $w data
  191.  
  192.     set opt(-move) 0
  193.     tixHandleOptions opt {-move} $args
  194.  
  195.     if {$data(widget) != {}} {
  196.     tixDeleteBindTag $data(widget) TixResizeHandleTag:$w
  197.     }
  198.  
  199.     set data(widget) $widget
  200.  
  201.     if {$data(widget) != {}} {
  202.     # Just in case TixResizeHandleTag was already there
  203.     tixDeleteBindTag $data(widget) TixResizeHandleTag:$w
  204.     tixAddBindTag $data(widget) TixResizeHandleTag:$w
  205.  
  206.     
  207.     set data(-x)      [winfo x      $data(widget)]
  208.     set data(-y)      [winfo y      $data(widget)]
  209.     set data(-width)  [winfo width  $data(widget)]
  210.     set data(-height) [winfo height $data(widget)]
  211.  
  212.     tixResizeHandle::show $w
  213.     tixResizeHandle::ComposeWindow $w
  214.  
  215.     # Now set the bindings
  216.     #
  217.     if {$opt(-move)} {
  218.         bind TixResizeHandleTag:$w <1> \
  219.         "tixResizeHandle::Attach $w %X %Y"
  220.         bind TixResizeHandleTag:$w <B1-Motion> \
  221.         "tixResizeHandle::BMotion $w %X %Y"
  222.         bind TixResizeHandleTag:$w <Any-Escape> \
  223.         "tixResizeHandle::BRelease $w 1 %X %Y"
  224.         bind TixResizeHandleTag:$w <ButtonRelease-1>\
  225.         "tixResizeHandle::BRelease $w 0 %X %Y"
  226.     } else {
  227.         # if "move" is false, then the widget won't be moved as a whole -- 
  228.         # ResizeHandle will only move its sides
  229.         bind TixResizeHandleTag:$w <1>          {;}
  230.         bind TixResizeHandleTag:$w <B1-Motion>     {;}
  231.         bind TixResizeHandleTag:$w <Any-Escape>     {;}
  232.         bind TixResizeHandleTag:$w <ButtonRelease-1> {;}
  233.     }
  234.     }
  235. }
  236.  
  237. proc tixResizeHandle::detachwidget {w} {
  238.     upvar #0 $w data
  239.  
  240.     if {$data(widget) != {}} {
  241.     tixDeleteBindTag $data(widget) TixResizeHandleTag:$w
  242.     }
  243.     tixResizeHandle::hide $w
  244. }
  245.  
  246. proc tixResizeHandle::show {w} {
  247.     upvar #0 $w data
  248.  
  249.     set data(shown) 1
  250.  
  251.     raise $data(w_ht)
  252.     raise $data(w_hb)
  253.     raise $data(w_hl)
  254.     raise $data(w_hr)
  255.  
  256.     raise $data(w_r00)
  257.     raise $data(w_r01)
  258.     raise $data(w_r10)
  259.     raise $data(w_r11)
  260.  
  261.     raise $data(w_bt)
  262.     raise $data(w_bb)
  263.     raise $data(w_bl)
  264.     raise $data(w_br)
  265.  
  266. #   tixCancleIdleTask tixResizeHandle::ComposeWindow $w
  267.     tixResizeHandle::ComposeWindow $w
  268. }
  269.  
  270.  
  271. proc tixResizeHandle::hide {w} {
  272.     upvar #0 $w data
  273.  
  274.     if {!$data(shown)} {
  275.     return
  276.     }
  277.  
  278.     set data(shown) 0
  279.  
  280.     place forget $data(w_r00)
  281.     place forget $data(w_r01)
  282.     place forget $data(w_r10)
  283.     place forget $data(w_r11)
  284.  
  285.     place forget $data(w_bt)
  286.     place forget $data(w_bb)
  287.     place forget $data(w_bl)
  288.     place forget $data(w_br)
  289.  
  290.     place forget $data(w_ht)
  291.     place forget $data(w_hb)
  292.     place forget $data(w_hl)
  293.     place forget $data(w_hr)
  294. }
  295.  
  296. proc tixResizeHandle::Destructor {w} {
  297.     upvar #0 $w data
  298.  
  299.     if {$data(widget) != {}} {
  300.     tixDeleteBindTag $data(widget) TixResizeHandleTag:$w
  301.     }
  302.  
  303.     catch {destroy $data(w_r01)}
  304.     catch {destroy $data(w_r10)}
  305.     catch {destroy $data(w_r11)}
  306.  
  307.     catch {destroy $data(w_bt)}
  308.     catch {destroy $data(w_bb)}
  309.     catch {destroy $data(w_bl)}
  310.     catch {destroy $data(w_br)}
  311.  
  312.     catch {destroy $data(w_ht)}
  313.     catch {destroy $data(w_hb)}
  314.     catch {destroy $data(w_hl)}
  315.     catch {destroy $data(w_hr)}
  316. }
  317.  
  318. #----------------------------------------------------------------------
  319. #       Private Methods Dealing With Attached Widgets
  320. #----------------------------------------------------------------------
  321. proc tixResizeHandle::Attach {w rx ry} {
  322.     upvar #0 $w data
  323.  
  324.     tixResizeHandle::dragstart $w $data(widget) 0 $rx $ry {1 1 0 0}
  325. }
  326.  
  327. proc tixResizeHandle::BMotion {w rx ry} {
  328.     tixVResize::drag $w $rx $ry
  329. }
  330.  
  331.  
  332. proc tixResizeHandle::BRelease {w isAbort rx ry} {
  333.     upvar #0 $w data
  334.  
  335.     tixVResize::dragend $w $data(widget) $isAbort $rx $ry
  336. }
  337.  
  338. #----------------------------------------------------------------------
  339. #         Private Methods
  340. #----------------------------------------------------------------------
  341. proc tixResizeHandle::DrawTmpLines {w} {
  342.     upvar #0 $w data
  343.  
  344.     set x1 $data(hf:x1)
  345.     set y1 $data(hf:y1)
  346.     set x2 $data(hf:x2)
  347.     set y2 $data(hf:y2)
  348.  
  349.     tixTmpLine $x1 $y1 $x2 $y1
  350.     tixTmpLine $x1 $y2 $x2 $y2
  351.     tixTmpLine $x1 $y1 $x1 $y2
  352.     tixTmpLine $x2 $y1 $x2 $y2
  353. }
  354.  
  355. # Place the hint frame to indicate the changes
  356. #
  357. proc tixResizeHandle::SetHintFrame {w x1 y1 width height} {
  358.     upvar #0 $w data
  359.  
  360.     # The four sides of the window
  361.     #
  362.     set x2 [expr "$x1+$width"]
  363.     set y2 [expr "$y1+$height"]
  364.  
  365.     set rx [winfo rootx [winfo parent $w]]
  366.     set ry [winfo rooty [winfo parent $w]]
  367.  
  368.     incr x1 $rx
  369.     incr y1 $ry
  370.     incr x2 $rx
  371.     incr y2 $ry
  372.  
  373.     if {[info exists data(hf:x1)]} {
  374.     tixResizeHandle::DrawTmpLines $w
  375.     }
  376.  
  377.     set data(hf:x1) $x1
  378.     set data(hf:y1) $y1
  379.     set data(hf:x2) $x2
  380.     set data(hf:y2) $y2
  381.  
  382.     tixResizeHandle::DrawTmpLines $w
  383. }
  384.  
  385. proc tixResizeHandle::ShowHintFrame {w} {
  386.     upvar #0 $w data
  387.  
  388.     place forget $data(w_ht)
  389.     place forget $data(w_hb)
  390.     place forget $data(w_hl)
  391.     place forget $data(w_hr)
  392.  
  393.     update
  394. }
  395.  
  396. proc tixResizeHandle::HideHintFrame {w} {
  397.     upvar #0 $w data
  398.  
  399.     tixResizeHandle::DrawTmpLines $w
  400.     unset data(hf:x1)
  401.     unset data(hf:y1)
  402.     unset data(hf:x2)
  403.     unset data(hf:y2)
  404. }
  405.  
  406. proc tixResizeHandle::UpdateSize {w x y width height} {
  407.     upvar #0 $w data
  408.  
  409.     set data(-x)      $x
  410.     set data(-y)      $y
  411.     set data(-width)  $width
  412.     set data(-height) $height
  413.  
  414.     tixResizeHandle::ComposeWindow $w
  415.  
  416.     if {$data(widget) != {}} {
  417.     place $data(widget) -x $x -y $y -width $width -height $height
  418.     }
  419.  
  420.     if {$data(-command) != {}} {
  421.     eval $data(-command) $x $y $width $height
  422.     }
  423. }
  424.  
  425. proc tixResizeHandle::ComposeWindow {w} {
  426.     upvar #0 $w data
  427.  
  428.     set px $data(-x)
  429.     set py $data(-y)
  430.     set pw $data(-width)
  431.     set ph $data(-height)
  432.  
  433.     # Show the hint frames
  434.     #
  435.     set x1 $px
  436.     set y1 $py
  437.     set x2 [expr "$px+$pw"]
  438.     set y2 [expr "$py+$ph"]
  439.  
  440.     place $data(w_ht) -x $x1 -y $y1 -width  $pw -bordermode outside
  441.     place $data(w_hb) -x $x1 -y $y2 -width  $pw -bordermode outside
  442.     place $data(w_hl) -x $x1 -y $y1 -height $ph -bordermode outside
  443.     place $data(w_hr) -x $x2 -y $y1 -height $ph -bordermode outside
  444.  
  445.     # Set the four corner resize handles
  446.     #
  447.     set sz_2 [expr $data(-handlesize)/2]
  448.  
  449.     set x1 [expr "$px - $sz_2"]
  450.     set y1 [expr "$py - $sz_2"]
  451.     set x2 [expr "$px - $sz_2" + $pw]
  452.     set y2 [expr "$py - $sz_2" + $ph]
  453.  
  454.     place $data(w_r00) -x $x1 -y $y1 \
  455.     -width $data(-handlesize) -height $data(-handlesize)
  456.     place $data(w_r01) -x $x1 -y $y2\
  457.     -width $data(-handlesize) -height $data(-handlesize)
  458.     place $data(w_r10) -x $x2 -y $y1\
  459.     -width $data(-handlesize) -height $data(-handlesize)
  460.     place $data(w_r11) -x $x2 -y $y2\
  461.     -width $data(-handlesize) -height $data(-handlesize)
  462.  
  463.  
  464.     # Set the four border resize handles
  465.     #
  466.     set mx [expr "$px + $pw/2 - $sz_2"]
  467.     set my [expr "$py + $ph/2 - $sz_2"]
  468.  
  469.     place $data(w_bt) -x $mx -y $y1 \
  470.     -width $data(-handlesize) -height $data(-handlesize)
  471.     place $data(w_bb) -x $mx -y $y2 \
  472.     -width $data(-handlesize) -height $data(-handlesize)
  473.     place $data(w_bl) -x $x1 -y $my \
  474.     -width $data(-handlesize) -height $data(-handlesize)
  475.     place $data(w_br) -x $x2 -y $my \
  476.     -width $data(-handlesize) -height $data(-handlesize)
  477. }
  478.